#ifndef MY_TASK_H_
#define MY_TASK_H_

#include <mutex>
#include <queue>
#include <atomic>
#include <functional>

#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"

using TaskFunction = std::function<void(void*)>;



#define CONFIG_QUEUE_LEN 16
#define CONFIG_STACK_SIZE   8192
#define CONFIG_CORE_ID 0

// 控制执行后台任务的次数
class MyTask {
public:
    struct Task {
        TaskFunction    fn;
        void*           arg;

        Task(TaskFunction func, void* argument) 
            : fn(func), arg(argument)
        {}
    };

    static MyTask& GetInstance() {
        static MyTask* background = new MyTask();
        return *background;
    }

    /// @brief 添加任务到队列
    /// @param fn 任务函数指针
    /// @param arg 任务参数
    /// @return 添加成功返回true
    bool Schedule(TaskFunction fn, void* arg=  nullptr);
    /// @brief 添加任务到队列
    /// @param task 无参数任务
    /// @return 任务添加成功返回true
    bool Schedule(std::function<void()> task);
    /// @brief 等待所有任务完成（包括队列中的）
    /// @param timeout_ms 超时时间
    /// @return 
    bool WaitForCompletion(uint32_t timeout_ms = 0);
    /// @brief 获取队列中等待执行的任务数量
    /// @return 
    size_t QueuedTasks() const;
    /// @brief 清空任务队列（不中断执行中的任务）
    void ClearQueue();
    /// @brief 获取活跃任务数量（执行+队列）
    /// @return 
    size_t ActiveTasks() const { return pending_tasks_.load(); }

private:
    MyTask();
    ~MyTask();

    MyTask(const MyTask&) = delete;
    MyTask& operator=(const MyTask&) = delete;
    MyTask(MyTask&&) = delete;
    MyTask& operator=(MyTask&&) = delete;
    
    void TaskHandler();

    QueueHandle_t       task_queue_;
    TaskHandle_t        task_handle_;
    SemaphoreHandle_t   completion_sem_;

    std::atomic<size_t> pending_tasks_{0};
    size_t              max_queue_size_;
};

#endif // !MY_TASK_H_